
// MIT License
// 
// Copyright (c) 2009-2017 Luca Piccioni
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// 
// This file is automatically generated

#pragma warning disable 649, 1572, 1573

// ReSharper disable RedundantUsingDirective
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

using Khronos;

// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
// ReSharper disable JoinDeclarationAndInitializer

namespace OpenGL
{
	public partial class Gl
	{
		/// <summary>
		/// [GL] glVertex2hNV: Binding for glVertex2hNV.
		/// </summary>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex2hNV(ushort x, ushort y)
		{
			Debug.Assert(Delegates.pglVertex2hNV != null, "pglVertex2hNV not implemented");
			Delegates.pglVertex2hNV(x, y);
			LogCommand("glVertex2hNV", null, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertex2hvNV: Binding for glVertex2hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex2hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 2);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertex2hvNV != null, "pglVertex2hvNV not implemented");
					Delegates.pglVertex2hvNV(p_v);
					LogCommand("glVertex2hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertex3hNV: Binding for glVertex3hNV.
		/// </summary>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex3hNV(ushort x, ushort y, ushort z)
		{
			Debug.Assert(Delegates.pglVertex3hNV != null, "pglVertex3hNV not implemented");
			Delegates.pglVertex3hNV(x, y, z);
			LogCommand("glVertex3hNV", null, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertex3hvNV: Binding for glVertex3hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex3hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertex3hvNV != null, "pglVertex3hvNV not implemented");
					Delegates.pglVertex3hvNV(p_v);
					LogCommand("glVertex3hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertex4hNV: Binding for glVertex4hNV.
		/// </summary>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex4hNV(ushort x, ushort y, ushort z, ushort w)
		{
			Debug.Assert(Delegates.pglVertex4hNV != null, "pglVertex4hNV not implemented");
			Delegates.pglVertex4hNV(x, y, z, w);
			LogCommand("glVertex4hNV", null, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertex4hvNV: Binding for glVertex4hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Vertex4hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertex4hvNV != null, "pglVertex4hvNV not implemented");
					Delegates.pglVertex4hvNV(p_v);
					LogCommand("glVertex4hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormal3hNV: Binding for glNormal3hNV.
		/// </summary>
		/// <param name="nx">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Normal3hNV(ushort nx, ushort ny, ushort nz)
		{
			Debug.Assert(Delegates.pglNormal3hNV != null, "pglNormal3hNV not implemented");
			Delegates.pglNormal3hNV(nx, ny, nz);
			LogCommand("glNormal3hNV", null, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormal3hvNV: Binding for glNormal3hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Normal3hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglNormal3hvNV != null, "pglNormal3hvNV not implemented");
					Delegates.pglNormal3hvNV(p_v);
					LogCommand("glNormal3hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glColor3hNV: Binding for glColor3hNV.
		/// </summary>
		/// <param name="red">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="green">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="blue">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Color3hNV(ushort red, ushort green, ushort blue)
		{
			Debug.Assert(Delegates.pglColor3hNV != null, "pglColor3hNV not implemented");
			Delegates.pglColor3hNV(red, green, blue);
			LogCommand("glColor3hNV", null, red, green, blue			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glColor3hvNV: Binding for glColor3hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Color3hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglColor3hvNV != null, "pglColor3hvNV not implemented");
					Delegates.pglColor3hvNV(p_v);
					LogCommand("glColor3hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glColor4hNV: Binding for glColor4hNV.
		/// </summary>
		/// <param name="red">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="green">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="blue">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="alpha">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Color4hNV(ushort red, ushort green, ushort blue, ushort alpha)
		{
			Debug.Assert(Delegates.pglColor4hNV != null, "pglColor4hNV not implemented");
			Delegates.pglColor4hNV(red, green, blue, alpha);
			LogCommand("glColor4hNV", null, red, green, blue, alpha			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glColor4hvNV: Binding for glColor4hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void Color4hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglColor4hvNV != null, "pglColor4hvNV not implemented");
					Delegates.pglColor4hvNV(p_v);
					LogCommand("glColor4hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord1hNV: Binding for glTexCoord1hNV.
		/// </summary>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord1hNV(ushort s)
		{
			Debug.Assert(Delegates.pglTexCoord1hNV != null, "pglTexCoord1hNV not implemented");
			Delegates.pglTexCoord1hNV(s);
			LogCommand("glTexCoord1hNV", null, s			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord1hvNV: Binding for glTexCoord1hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord1hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 1);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglTexCoord1hvNV != null, "pglTexCoord1hvNV not implemented");
					Delegates.pglTexCoord1hvNV(p_v);
					LogCommand("glTexCoord1hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord2hNV: Binding for glTexCoord2hNV.
		/// </summary>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord2hNV(ushort s, ushort t)
		{
			Debug.Assert(Delegates.pglTexCoord2hNV != null, "pglTexCoord2hNV not implemented");
			Delegates.pglTexCoord2hNV(s, t);
			LogCommand("glTexCoord2hNV", null, s, t			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord2hvNV: Binding for glTexCoord2hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord2hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 2);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglTexCoord2hvNV != null, "pglTexCoord2hvNV not implemented");
					Delegates.pglTexCoord2hvNV(p_v);
					LogCommand("glTexCoord2hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord3hNV: Binding for glTexCoord3hNV.
		/// </summary>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="r">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord3hNV(ushort s, ushort t, ushort r)
		{
			Debug.Assert(Delegates.pglTexCoord3hNV != null, "pglTexCoord3hNV not implemented");
			Delegates.pglTexCoord3hNV(s, t, r);
			LogCommand("glTexCoord3hNV", null, s, t, r			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord3hvNV: Binding for glTexCoord3hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord3hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglTexCoord3hvNV != null, "pglTexCoord3hvNV not implemented");
					Delegates.pglTexCoord3hvNV(p_v);
					LogCommand("glTexCoord3hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord4hNV: Binding for glTexCoord4hNV.
		/// </summary>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="r">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="q">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord4hNV(ushort s, ushort t, ushort r, ushort q)
		{
			Debug.Assert(Delegates.pglTexCoord4hNV != null, "pglTexCoord4hNV not implemented");
			Delegates.pglTexCoord4hNV(s, t, r, q);
			LogCommand("glTexCoord4hNV", null, s, t, r, q			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTexCoord4hvNV: Binding for glTexCoord4hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void TexCoord4hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglTexCoord4hvNV != null, "pglTexCoord4hvNV not implemented");
					Delegates.pglTexCoord4hvNV(p_v);
					LogCommand("glTexCoord4hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord1hNV: Binding for glMultiTexCoord1hNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord1hNV(TextureUnit target, ushort s)
		{
			Debug.Assert(Delegates.pglMultiTexCoord1hNV != null, "pglMultiTexCoord1hNV not implemented");
			Delegates.pglMultiTexCoord1hNV((int)target, s);
			LogCommand("glMultiTexCoord1hNV", null, target, s			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord1hvNV: Binding for glMultiTexCoord1hvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord1hNV(TextureUnit target, ushort[] v)
		{
			Debug.Assert(v.Length >= 1);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglMultiTexCoord1hvNV != null, "pglMultiTexCoord1hvNV not implemented");
					Delegates.pglMultiTexCoord1hvNV((int)target, p_v);
					LogCommand("glMultiTexCoord1hvNV", null, target, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord2hNV: Binding for glMultiTexCoord2hNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord2hNV(TextureUnit target, ushort s, ushort t)
		{
			Debug.Assert(Delegates.pglMultiTexCoord2hNV != null, "pglMultiTexCoord2hNV not implemented");
			Delegates.pglMultiTexCoord2hNV((int)target, s, t);
			LogCommand("glMultiTexCoord2hNV", null, target, s, t			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord2hvNV: Binding for glMultiTexCoord2hvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord2hNV(TextureUnit target, ushort[] v)
		{
			Debug.Assert(v.Length >= 2);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglMultiTexCoord2hvNV != null, "pglMultiTexCoord2hvNV not implemented");
					Delegates.pglMultiTexCoord2hvNV((int)target, p_v);
					LogCommand("glMultiTexCoord2hvNV", null, target, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord3hNV: Binding for glMultiTexCoord3hNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="r">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord3hNV(TextureUnit target, ushort s, ushort t, ushort r)
		{
			Debug.Assert(Delegates.pglMultiTexCoord3hNV != null, "pglMultiTexCoord3hNV not implemented");
			Delegates.pglMultiTexCoord3hNV((int)target, s, t, r);
			LogCommand("glMultiTexCoord3hNV", null, target, s, t, r			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord3hvNV: Binding for glMultiTexCoord3hvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord3hNV(TextureUnit target, ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglMultiTexCoord3hvNV != null, "pglMultiTexCoord3hvNV not implemented");
					Delegates.pglMultiTexCoord3hvNV((int)target, p_v);
					LogCommand("glMultiTexCoord3hvNV", null, target, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord4hNV: Binding for glMultiTexCoord4hNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="s">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="t">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="r">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="q">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord4hNV(TextureUnit target, ushort s, ushort t, ushort r, ushort q)
		{
			Debug.Assert(Delegates.pglMultiTexCoord4hNV != null, "pglMultiTexCoord4hNV not implemented");
			Delegates.pglMultiTexCoord4hNV((int)target, s, t, r, q);
			LogCommand("glMultiTexCoord4hNV", null, target, s, t, r, q			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glMultiTexCoord4hvNV: Binding for glMultiTexCoord4hvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:TextureUnit"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void MultiTexCoord4hNV(TextureUnit target, ushort[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglMultiTexCoord4hvNV != null, "pglMultiTexCoord4hvNV not implemented");
					Delegates.pglMultiTexCoord4hvNV((int)target, p_v);
					LogCommand("glMultiTexCoord4hvNV", null, target, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glFogCoordhNV: Binding for glFogCoordhNV.
		/// </summary>
		/// <param name="fog">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void FogCoordhNV(ushort fog)
		{
			Debug.Assert(Delegates.pglFogCoordhNV != null, "pglFogCoordhNV not implemented");
			Delegates.pglFogCoordhNV(fog);
			LogCommand("glFogCoordhNV", null, fog			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glFogCoordhvNV: Binding for glFogCoordhvNV.
		/// </summary>
		/// <param name="fog">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void FogCoordhNV(ushort[] fog)
		{
			Debug.Assert(fog.Length >= 1);
			unsafe {
				fixed (ushort* p_fog = fog)
				{
					Debug.Assert(Delegates.pglFogCoordhvNV != null, "pglFogCoordhvNV not implemented");
					Delegates.pglFogCoordhvNV(p_fog);
					LogCommand("glFogCoordhvNV", null, fog					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glSecondaryColor3hNV: Binding for glSecondaryColor3hNV.
		/// </summary>
		/// <param name="red">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="green">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="blue">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void SecondaryColor3hNV(ushort red, ushort green, ushort blue)
		{
			Debug.Assert(Delegates.pglSecondaryColor3hNV != null, "pglSecondaryColor3hNV not implemented");
			Delegates.pglSecondaryColor3hNV(red, green, blue);
			LogCommand("glSecondaryColor3hNV", null, red, green, blue			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glSecondaryColor3hvNV: Binding for glSecondaryColor3hvNV.
		/// </summary>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void SecondaryColor3hNV(ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglSecondaryColor3hvNV != null, "pglSecondaryColor3hvNV not implemented");
					Delegates.pglSecondaryColor3hvNV(p_v);
					LogCommand("glSecondaryColor3hvNV", null, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexWeighthNV: Binding for glVertexWeighthNV.
		/// </summary>
		/// <param name="weight">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexWeighthNV(ushort weight)
		{
			Debug.Assert(Delegates.pglVertexWeighthNV != null, "pglVertexWeighthNV not implemented");
			Delegates.pglVertexWeighthNV(weight);
			LogCommand("glVertexWeighthNV", null, weight			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexWeighthvNV: Binding for glVertexWeighthvNV.
		/// </summary>
		/// <param name="weight">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexWeighthNV(ushort[] weight)
		{
			Debug.Assert(weight.Length >= 1);
			unsafe {
				fixed (ushort* p_weight = weight)
				{
					Debug.Assert(Delegates.pglVertexWeighthvNV != null, "pglVertexWeighthvNV not implemented");
					Delegates.pglVertexWeighthvNV(p_weight);
					LogCommand("glVertexWeighthvNV", null, weight					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib1hNV: Binding for glVertexAttrib1hNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib1NV(uint index, ushort x)
		{
			Debug.Assert(Delegates.pglVertexAttrib1hNV != null, "pglVertexAttrib1hNV not implemented");
			Delegates.pglVertexAttrib1hNV(index, x);
			LogCommand("glVertexAttrib1hNV", null, index, x			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib1hvNV: Binding for glVertexAttrib1hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib1hvNV(uint index, ushort[] v)
		{
			Debug.Assert(v.Length >= 1);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttrib1hvNV != null, "pglVertexAttrib1hvNV not implemented");
					Delegates.pglVertexAttrib1hvNV(index, p_v);
					LogCommand("glVertexAttrib1hvNV", null, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib2hNV: Binding for glVertexAttrib2hNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib2NV(uint index, ushort x, ushort y)
		{
			Debug.Assert(Delegates.pglVertexAttrib2hNV != null, "pglVertexAttrib2hNV not implemented");
			Delegates.pglVertexAttrib2hNV(index, x, y);
			LogCommand("glVertexAttrib2hNV", null, index, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib2hvNV: Binding for glVertexAttrib2hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib2hvNV(uint index, ushort[] v)
		{
			Debug.Assert(v.Length >= 2);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttrib2hvNV != null, "pglVertexAttrib2hvNV not implemented");
					Delegates.pglVertexAttrib2hvNV(index, p_v);
					LogCommand("glVertexAttrib2hvNV", null, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib3hNV: Binding for glVertexAttrib3hNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib3NV(uint index, ushort x, ushort y, ushort z)
		{
			Debug.Assert(Delegates.pglVertexAttrib3hNV != null, "pglVertexAttrib3hNV not implemented");
			Delegates.pglVertexAttrib3hNV(index, x, y, z);
			LogCommand("glVertexAttrib3hNV", null, index, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib3hvNV: Binding for glVertexAttrib3hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib3hvNV(uint index, ushort[] v)
		{
			Debug.Assert(v.Length >= 3);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttrib3hvNV != null, "pglVertexAttrib3hvNV not implemented");
					Delegates.pglVertexAttrib3hvNV(index, p_v);
					LogCommand("glVertexAttrib3hvNV", null, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib4hNV: Binding for glVertexAttrib4hNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:ushort"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:ushort"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib4NV(uint index, ushort x, ushort y, ushort z, ushort w)
		{
			Debug.Assert(Delegates.pglVertexAttrib4hNV != null, "pglVertexAttrib4hNV not implemented");
			Delegates.pglVertexAttrib4hNV(index, x, y, z, w);
			LogCommand("glVertexAttrib4hNV", null, index, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttrib4hvNV: Binding for glVertexAttrib4hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttrib4hvNV(uint index, ushort[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttrib4hvNV != null, "pglVertexAttrib4hvNV not implemented");
					Delegates.pglVertexAttrib4hvNV(index, p_v);
					LogCommand("glVertexAttrib4hvNV", null, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs1hvNV: Binding for glVertexAttribs1hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttribs1hvNV(uint index, ushort[] v)
		{
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs1hvNV != null, "pglVertexAttribs1hvNV not implemented");
					Delegates.pglVertexAttribs1hvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs1hvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs2hvNV: Binding for glVertexAttribs2hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttribs2hvNV(uint index, ushort[] v)
		{
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs2hvNV != null, "pglVertexAttribs2hvNV not implemented");
					Delegates.pglVertexAttribs2hvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs2hvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs3hvNV: Binding for glVertexAttribs3hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttribs3hvNV(uint index, ushort[] v)
		{
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs3hvNV != null, "pglVertexAttribs3hvNV not implemented");
					Delegates.pglVertexAttribs3hvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs3hvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs4hvNV: Binding for glVertexAttribs4hvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:ushort[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_half_float")]
		public static void VertexAttribs4hvNV(uint index, ushort[] v)
		{
			unsafe {
				fixed (ushort* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs4hvNV != null, "pglVertexAttribs4hvNV not implemented");
					Delegates.pglVertexAttribs4hvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs4hvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		internal static unsafe partial class Delegates
		{
			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex2hNV(ushort x, ushort y);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex2hNV pglVertex2hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex2hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex2hvNV pglVertex2hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex3hNV(ushort x, ushort y, ushort z);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex3hNV pglVertex3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex3hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex3hvNV pglVertex3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex4hNV(ushort x, ushort y, ushort z, ushort w);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex4hNV pglVertex4hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertex4hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertex4hvNV pglVertex4hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormal3hNV(ushort nx, ushort ny, ushort nz);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glNormal3hNV pglNormal3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormal3hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glNormal3hvNV pglNormal3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glColor3hNV(ushort red, ushort green, ushort blue);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glColor3hNV pglColor3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glColor3hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glColor3hvNV pglColor3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glColor4hNV(ushort red, ushort green, ushort blue, ushort alpha);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glColor4hNV pglColor4hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glColor4hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glColor4hvNV pglColor4hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord1hNV(ushort s);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord1hNV pglTexCoord1hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord1hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord1hvNV pglTexCoord1hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord2hNV(ushort s, ushort t);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord2hNV pglTexCoord2hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord2hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord2hvNV pglTexCoord2hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord3hNV(ushort s, ushort t, ushort r);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord3hNV pglTexCoord3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord3hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord3hvNV pglTexCoord3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord4hNV(ushort s, ushort t, ushort r, ushort q);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord4hNV pglTexCoord4hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTexCoord4hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glTexCoord4hvNV pglTexCoord4hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord1hNV(int target, ushort s);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord1hNV pglMultiTexCoord1hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord1hvNV(int target, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord1hvNV pglMultiTexCoord1hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord2hNV(int target, ushort s, ushort t);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord2hNV pglMultiTexCoord2hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord2hvNV(int target, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord2hvNV pglMultiTexCoord2hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord3hNV(int target, ushort s, ushort t, ushort r);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord3hNV pglMultiTexCoord3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord3hvNV(int target, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord3hvNV pglMultiTexCoord3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord4hNV(int target, ushort s, ushort t, ushort r, ushort q);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord4hNV pglMultiTexCoord4hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glMultiTexCoord4hvNV(int target, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glMultiTexCoord4hvNV pglMultiTexCoord4hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glFogCoordhNV(ushort fog);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glFogCoordhNV pglFogCoordhNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glFogCoordhvNV(ushort* fog);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glFogCoordhvNV pglFogCoordhvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glSecondaryColor3hNV(ushort red, ushort green, ushort blue);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glSecondaryColor3hNV pglSecondaryColor3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glSecondaryColor3hvNV(ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glSecondaryColor3hvNV pglSecondaryColor3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexWeighthNV(ushort weight);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexWeighthNV pglVertexWeighthNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexWeighthvNV(ushort* weight);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexWeighthvNV pglVertexWeighthvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib1hNV(uint index, ushort x);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib1hNV pglVertexAttrib1hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib1hvNV(uint index, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib1hvNV pglVertexAttrib1hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib2hNV(uint index, ushort x, ushort y);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib2hNV pglVertexAttrib2hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib2hvNV(uint index, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib2hvNV pglVertexAttrib2hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib3hNV(uint index, ushort x, ushort y, ushort z);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib3hNV pglVertexAttrib3hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib3hvNV(uint index, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib3hvNV pglVertexAttrib3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib4hNV(uint index, ushort x, ushort y, ushort z, ushort w);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib4hNV pglVertexAttrib4hNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttrib4hvNV(uint index, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttrib4hvNV pglVertexAttrib4hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs1hvNV(uint index, int n, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttribs1hvNV pglVertexAttribs1hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs2hvNV(uint index, int n, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttribs2hvNV pglVertexAttribs2hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs3hvNV(uint index, int n, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttribs3hvNV pglVertexAttribs3hvNV;

			[RequiredByFeature("GL_NV_half_float")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs4hvNV(uint index, int n, ushort* v);

			[RequiredByFeature("GL_NV_half_float")]
			[ThreadStatic]
			internal static glVertexAttribs4hvNV pglVertexAttribs4hvNV;

		}
	}

}
